home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / strategy / xpuzzles.3 / xpuzzles / xpuzzles-5.3.1 / xhexagons / xmhexagons.c < prev   
C/C++ Source or Header  |  1996-02-07  |  13KB  |  442 lines
  1. /*
  2. # MOTIF-BASED HEXAGONS
  3. #
  4. #  xmhexagons.c
  5. #
  6. ###
  7. #
  8. #  Copyright (c) 1993 - 96    David Albert Bagley, bagleyd@hertz.njit.edu
  9. #
  10. #                   All Rights Reserved
  11. #
  12. #  Permission to use, copy, modify, and distribute this software and
  13. #  its documentation for any purpose and without fee is hereby granted,
  14. #  provided that the above copyright notice appear in all copies and
  15. #  that both that copyright notice and this permission notice appear in
  16. #  supporting documentation, and that the name of the author not be
  17. #  used in advertising or publicity pertaining to distribution of the
  18. #  software without specific, written prior permission.
  19. #
  20. #  This program is distributed in the hope that it will be "useful",
  21. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  23. #
  24. */
  25.  
  26. /*
  27.   Version 5: 95/10/01 Xt/Motif
  28.   Version 4: 94/06/07 Xt
  29.   Version 3: 93/04/01 Motif
  30.   Version 2: 92/01/07 XView
  31.   Version 1: 91/09/05 SunView
  32. */
  33.  
  34. #include <stdlib.h>
  35. #include <stdio.h>
  36. #ifdef VMS
  37. #include <unixlib.h>
  38. #define getlogin cuserid
  39. #else
  40. #ifndef apollo
  41. #include <unistd.h>
  42. #endif
  43. #endif
  44. #include <X11/Intrinsic.h>
  45. #include <X11/StringDefs.h>
  46. #include <X11/Shell.h>
  47. #include <X11/cursorfont.h>
  48. #include <Xm/PanedW.h>
  49. #include <Xm/RowColumn.h>
  50. #include <Xm/Label.h>
  51. #include <Xm/LabelG.h>
  52. #include <Xm/Scale.h>
  53. #include <Xm/ToggleB.h>
  54. #include "Hexagons.h"
  55. #include "hexagons.xbm"
  56. #include "mouse-l.xbm"
  57. #include "mouse-r.xbm"
  58.  
  59. #ifndef SCOREFILE
  60. #define SCOREFILE "/usr/games/lib/hexagons.scores"
  61. #endif
  62.  
  63. /* The following are in HexagonsP.h also */
  64. #define MINHEXAGONS 1
  65. #define MAXORIENT 2
  66. #define NOCORN 0
  67. #define CORNERS 1
  68.  
  69. #define MAXHEXAGONS 12
  70. #define MAXRECORD 32767
  71.  
  72. static void Initialize();
  73. static void CallbackHexagons();
  74.  
  75. static void PrintRecord();
  76. static int HandleSolved();
  77. static void ReadRecords();
  78. static void WriteRecords();
  79.  
  80. static void motif_printf();
  81. static void HexSlider();
  82. static void CornersToggle();
  83.  
  84. static Arg arg[2];
  85. static Widget moves, record, message, hexagons, cornersSwitch, hex;
  86. static int hexagonsRecord[MAXORIENT][MAXHEXAGONS - MINHEXAGONS + 1],
  87.   movesDsp = 0;
  88. static char messageDsp[128] = "Welcome";
  89.  
  90. static void Usage()
  91. {
  92.   (void) fprintf(stderr, "usage: xmhexagons\n");
  93.   (void) fprintf(stderr,
  94.     "\t[-geometry [{width}][x{height}][{+-}{xoff}[{+-}{yoff}]]]\n");
  95.   (void) fprintf(stderr,
  96.     "\t[-display [{host}]:[{vs}]][-fg {color}] [-bg {color}]\n");
  97.   (void) fprintf(stderr,
  98.     "\t[-tile {color}] [-{border|bd} {color}] [-size {int}] [-[no]corners]\n");
  99.   exit(1);
  100. }
  101.  
  102. static XrmOptionDescRec options[] = {
  103.   {"-fg",        "*hexagons.Foreground",    XrmoptionSepArg,    NULL},
  104.   {"-bg",        "*Background",        XrmoptionSepArg,    NULL},
  105.   {"-foreground",    "*hexagons.Foreground",    XrmoptionSepArg,    NULL},
  106.   {"-background",    "*Background",        XrmoptionSepArg,    NULL},
  107.   {"-tile",        "*hexagons.tileColor",    XrmoptionSepArg,    NULL},
  108.   {"-border",        "*hexagons.tileBorder",    XrmoptionSepArg,    NULL},
  109.   {"-bd",        "*hexagons.tileBorder",    XrmoptionSepArg,    NULL},
  110.   {"-size",        "*hexagons.size",    XrmoptionSepArg,    NULL},
  111.   {"-corners",        "*hexagons.corners",    XrmoptionNoArg,        "TRUE"},
  112.   {"-nocorners",    "*hexagons.corners",    XrmoptionNoArg,        "FALSE"}
  113. };
  114.  
  115. int main(argc, argv)
  116.   int argc;
  117.   char *argv[];
  118. {
  119.   Widget toplevel; 
  120.   Widget panel, panel2, rowcol, rowcol2;
  121.   Pixmap mouseLeftCursor, mouseRightCursor;
  122.   Pixel fg, bg;
  123.  
  124.   toplevel = XtInitialize(argv[0], "Hexagons",
  125.     options, XtNumber(options), &argc, argv);
  126.   if (argc != 1)
  127.     Usage();
  128.  
  129.   XtSetArg(arg[0], XtNiconPixmap,
  130.     XCreateBitmapFromData(XtDisplay(toplevel),
  131.       RootWindowOfScreen(XtScreen(toplevel)),
  132.       (char *) hexagons_bits, hexagons_width, hexagons_height));
  133.   XtSetArg(arg[1], XmNkeyboardFocusPolicy, XmPOINTER); /* not XmEXPLICIT */
  134.   XtSetValues(toplevel, arg, 2);
  135.   panel = XtCreateManagedWidget("panel", xmPanedWindowWidgetClass, toplevel,
  136.     NULL, 0);
  137.   panel2 = XtVaCreateManagedWidget("panel2", xmPanedWindowWidgetClass, panel,
  138.     XmNseparatorOn, False,
  139.     XmNsashWidth, 1,
  140.     XmNsashHeight, 1,
  141.     NULL);
  142.  
  143.   rowcol = XtVaCreateManagedWidget("Rowcol", xmRowColumnWidgetClass, panel2,
  144.     XmNnumColumns, 2,
  145.     XmNorientation, XmHORIZONTAL,
  146.     XmNpacking, XmPACK_COLUMN,
  147.     NULL);
  148.   XtVaGetValues(rowcol, XmNforeground, &fg, XmNbackground, &bg, NULL);
  149.   mouseLeftCursor = XCreatePixmapFromBitmapData(XtDisplay(rowcol),
  150.     RootWindowOfScreen(XtScreen(rowcol)), mouse_left_bits,
  151.     mouse_left_width, mouse_left_height, fg, bg,
  152.     DefaultDepthOfScreen(XtScreen(rowcol)));
  153.   mouseRightCursor = XCreatePixmapFromBitmapData(XtDisplay(rowcol),
  154.     RootWindowOfScreen(XtScreen(rowcol)), mouse_right_bits,
  155.     mouse_right_width, mouse_right_height, fg, bg,
  156.     DefaultDepthOfScreen(XtScreen(rowcol)));
  157.   XtVaCreateManagedWidget("mouseLeftText", xmLabelGadgetClass, rowcol,
  158.     XtVaTypedArg, XmNlabelString, XmRString, "Move tile", 10, NULL);
  159.   XtVaCreateManagedWidget("mouseLeft", xmLabelGadgetClass, rowcol,
  160.     XmNlabelType, XmPIXMAP, XmNlabelPixmap, mouseLeftCursor, NULL);
  161.   XtVaCreateManagedWidget("mouseRightText", xmLabelGadgetClass, rowcol,
  162.     XtVaTypedArg, XmNlabelString, XmRString, "Randomize", 10, NULL);
  163.   XtVaCreateManagedWidget("mouseRight", xmLabelGadgetClass, rowcol,
  164.     XmNlabelType, XmPIXMAP, XmNlabelPixmap, mouseRightCursor, NULL);
  165.   XtVaCreateManagedWidget("movesText", xmLabelGadgetClass, rowcol,
  166.     XtVaTypedArg, XmNlabelString, XmRString, "Moves", 6, NULL);
  167.   moves = XtVaCreateManagedWidget("0", xmLabelWidgetClass, rowcol, NULL);
  168.   XtVaCreateManagedWidget("recordText", xmLabelGadgetClass, rowcol,
  169.     XtVaTypedArg, XmNlabelString, XmRString, "Record", 7, NULL);
  170.   record = XtVaCreateManagedWidget("0", xmLabelWidgetClass, rowcol, NULL);
  171.  
  172.   rowcol2 = XtVaCreateManagedWidget("Rowcol2", xmRowColumnWidgetClass, panel2,
  173.     NULL);
  174.   XtVaGetValues(rowcol2, XmNforeground, &fg, XmNbackground, &bg, NULL);
  175.   hex = XtVaCreateManagedWidget("hexs", xmScaleWidgetClass, rowcol2,
  176.     XtVaTypedArg, XmNtitleString, XmRString, "Hexs", 5,
  177.     XmNminimum, MINHEXAGONS,
  178.     XmNmaximum, MAXHEXAGONS,
  179.     XmNvalue, MINHEXAGONS,
  180.     XmNshowValue, True,
  181.     XmNorientation, XmHORIZONTAL,
  182.     NULL);
  183.   XtAddCallback(hex, XmNvalueChangedCallback, HexSlider, NULL);
  184.   cornersSwitch = XtVaCreateManagedWidget ("Corners",
  185.     xmToggleButtonWidgetClass, rowcol2,
  186.     NULL);
  187.   XtAddCallback(cornersSwitch, XmNvalueChangedCallback, CornersToggle, NULL);
  188.   message = XtVaCreateManagedWidget("Play Hexagons! (use mouse or keypad)",
  189.     xmLabelWidgetClass, rowcol2,
  190.     NULL);
  191.  
  192.   hexagons = XtCreateManagedWidget("hexagons", hexagonsWidgetClass, panel,
  193.     NULL, 0);
  194.   XtAddCallback(hexagons, XtNselectCallback, CallbackHexagons, NULL);
  195.   Initialize(hexagons);
  196.   XtRealizeWidget(toplevel);
  197.   XGrabButton(XtDisplay(hexagons), AnyButton, AnyModifier, XtWindow(hexagons),
  198.     TRUE, ButtonPressMask | ButtonMotionMask | ButtonReleaseMask,
  199.     GrabModeAsync, GrabModeAsync, XtWindow(hexagons),
  200.     XCreateFontCursor(XtDisplay(hexagons), XC_crosshair));
  201.   XtMainLoop();
  202.  
  203. #ifdef VMS
  204.   return 1;
  205. #else
  206.   return 0;
  207. #endif
  208. }
  209.  
  210. static void Initialize(w)
  211.   Widget w;
  212. {
  213.   int size;
  214.   Boolean corners;
  215.  
  216.   XtVaSetValues(w,
  217.     XtNstart, FALSE,
  218.     NULL);
  219.   XtVaGetValues(w,
  220.     XtNsize, &size,
  221.     XtNcorners, &corners,
  222.     NULL);
  223.   if (size <= MAXHEXAGONS)
  224.     XmScaleSetValue(hex, size);
  225.   XmToggleButtonSetState(cornersSwitch, corners, True);
  226.   ReadRecords();
  227.   PrintRecord(size, corners);
  228. }
  229.  
  230. static void CallbackHexagons(w, clientData, callData)
  231.   Widget w;
  232.   caddr_t clientData;
  233.   hexagonsCallbackStruct *callData;
  234. {
  235.   int size;
  236.   Boolean corners;
  237.  
  238.   XtVaGetValues(w,
  239.     XtNsize, &size,
  240.     XtNcorners, &corners,
  241.     NULL);
  242.   (void) strcpy(messageDsp, "");
  243.   switch (callData->reason) {
  244.     case HEXAGONS_RESTORE:
  245.     case HEXAGONS_RESET:
  246.       movesDsp = 0;
  247.       break;
  248.     case HEXAGONS_BLOCKED:
  249.       (void) strcpy(messageDsp, "Blocked");
  250.       break;
  251.     case HEXAGONS_SPACE:
  252.       /*(void) strcpy(messageDsp, "Spaces can't move");*/  /* Too annoying */
  253.       break;
  254.     case HEXAGONS_IGNORE:
  255.       (void) strcpy(messageDsp, "Randomize to start");
  256.       break;
  257.     case HEXAGONS_MOVED:
  258.       movesDsp++;
  259.       XtSetArg(arg[0], XtNstart, TRUE);
  260.       XtSetValues(w, arg, 1);
  261.       break;
  262.     case HEXAGONS_SOLVED:
  263.       if (HandleSolved(movesDsp, size, corners))
  264.         (void) sprintf(messageDsp, "Congratulations %s!!", getlogin());
  265.       else
  266.         (void) strcpy(messageDsp, "Solved!");
  267.       XtSetArg(arg[0], XtNstart, FALSE);
  268.       XtSetValues(w, arg, 1);
  269.       break;
  270.     case HEXAGONS_RANDOMIZE:
  271.       movesDsp = 0;
  272.       XtSetArg(arg[0], XtNstart, FALSE);
  273.       XtSetValues(w, arg, 1);
  274.       break;
  275.     case HEXAGONS_DEC:
  276.       movesDsp = 0;
  277.       size--;
  278.       PrintRecord(size, corners);
  279.       XtSetArg(arg[0], XtNsize, size);
  280.       XtSetValues(w, arg, 1);
  281.       if (size <= MAXHEXAGONS)
  282.         XmScaleSetValue(hex, size);
  283.       break;
  284.     case HEXAGONS_INC:
  285.       movesDsp = 0;
  286.       size++;
  287.       PrintRecord(size, corners);
  288.       XtSetArg(arg[0], XtNsize, size);
  289.       XtSetValues(w, arg, 1);
  290.       if (size <= MAXHEXAGONS)
  291.         XmScaleSetValue(hex, size);
  292.       break;
  293.     case HEXAGONS_CORNERS:
  294.       movesDsp = 0;
  295.       corners = !corners;
  296.       PrintRecord(size, corners);
  297.       XtSetArg(arg[0], XtNcorners, corners);
  298.       XtSetValues(w, arg, 1);
  299.       XmToggleButtonSetState(cornersSwitch, corners, True);
  300.       break;
  301.     case HEXAGONS_COMPUTED:
  302.       XtSetArg(arg[0], XtNstart, FALSE);
  303.       XtSetValues(w, arg, 1);
  304.       break;
  305.     case HEXAGONS_UNDO:
  306.       movesDsp--;
  307.       XtSetArg(arg[0], XtNstart, TRUE);
  308.       XtSetValues(w, arg, 1);
  309.       break;
  310.   }
  311.   motif_printf(message, "%s", messageDsp);
  312.   motif_printf(moves, "%d", movesDsp);
  313. }
  314.  
  315. static void HexSlider(w, clientData, cbs)
  316.   Widget w;
  317.   XtPointer clientData;
  318.   XmScaleCallbackStruct *cbs;
  319. {
  320.   int size = cbs->value, old;
  321.  
  322.   XtVaGetValues(hexagons,
  323.     XtNsize, &old,
  324.     NULL);  
  325.   if (old != size) {
  326.     XtVaSetValues(hexagons,
  327.       XtNsize, size,
  328.       NULL);  
  329.     movesDsp = 0;
  330.     motif_printf(moves, "%d", movesDsp);
  331.     PrintRecord(size, XmToggleButtonGetState(cornersSwitch));
  332.   }
  333. }
  334.  
  335. static void CornersToggle(w, clientData, cbs)
  336.   Widget w;
  337.   XtPointer clientData;
  338.   XmToggleButtonCallbackStruct *cbs;
  339. {
  340.   int size;
  341.   Boolean corners = cbs->set;
  342.  
  343.   XtVaSetValues(hexagons,
  344.     XtNcorners, corners,
  345.     NULL);
  346.   XtVaGetValues(hexagons,
  347.     XtNsize, &size,
  348.     NULL);
  349.   movesDsp = 0;
  350.   motif_printf(moves, "%d", movesDsp);
  351.   PrintRecord(size, corners);
  352. }
  353.  
  354. static void PrintRecord(size, corners)
  355.   int size;
  356.   Boolean corners;
  357. {
  358.   int i = (corners) ? 1 : 0, j = size - MINHEXAGONS;
  359.  
  360.   if (size > MAXHEXAGONS)
  361.     motif_printf(record, "NOT RECORDED"); 
  362.   if (hexagonsRecord[i][j] >= MAXRECORD)
  363.     motif_printf(record, "NEVER");
  364.   else
  365.     motif_printf(record, "%d", hexagonsRecord[i][j]);
  366. }
  367.  
  368.  
  369. static int HandleSolved(counter, size, corners)
  370.   int counter, size, corners;
  371. {
  372.   int i = (corners) ? 1 : 0, j = size - MINHEXAGONS;
  373.  
  374.   if (size <= MAXHEXAGONS && counter < hexagonsRecord[i][j]) {
  375.     hexagonsRecord[i][j] = counter;
  376.     WriteRecords();
  377.     PrintRecord(size, corners);
  378.     return TRUE;
  379.   }
  380.   return FALSE;
  381. }
  382.  
  383. static void ReadRecords()
  384. {
  385.   FILE *fp;
  386.   int i, j, n;
  387.  
  388.   for (i = 0; i < MAXORIENT; i++)
  389.     for (j = 0; j < MAXHEXAGONS - MINHEXAGONS + 1; j++)
  390.       hexagonsRecord[i][j] = MAXRECORD;
  391.   if ((fp = fopen(SCOREFILE, "r")) == NULL)
  392.     motif_printf(message, "Can not open %s, taking defaults.\n", SCOREFILE);
  393.   else {
  394.     for (i = 0; i < MAXORIENT; i++)
  395.       for (j = 0; j < MAXHEXAGONS - MINHEXAGONS + 1; j++) {
  396.         (void) fscanf(fp, "%d", &n);
  397.         hexagonsRecord[i][j] = n;
  398.     }
  399.     (void) fclose(fp);
  400.   }
  401. }
  402.  
  403. static void WriteRecords()
  404. {
  405.   FILE *fp;
  406.   int i, j;
  407.  
  408.   if ((fp = fopen(SCOREFILE, "w")) == NULL)
  409.     motif_printf(message, "Can not write to %s.", SCOREFILE);
  410.   else {
  411.     for (i = 0; i < MAXORIENT; i++) {
  412.       for (j = 0; j < MAXHEXAGONS - MINHEXAGONS + 1; j++)
  413.         (void) fprintf(fp, "%d ", hexagonsRecord[i][j]);
  414.       (void) fprintf(fp, "\n");
  415.     }
  416.     (void) fclose(fp);
  417.   }
  418. }
  419.  
  420. #include <varargs.h>
  421. static void motif_printf(va_alist)
  422.   va_dcl
  423. {
  424.   Widget w;
  425.   char *format;
  426.   va_list args;
  427.   char str[1000];
  428.   Arg wargs[10];
  429.   XmString xmstr;
  430.  
  431.   va_start(args);
  432.   w = va_arg(args, Widget);
  433.   if (!XtIsSubclass(w, xmLabelWidgetClass))
  434.     XtError("xs_motif_printf() requires a Label Widget");
  435.   format = va_arg(args, char *);
  436.   (void) vsprintf(str, format, args);
  437.   xmstr = XmStringCreateLtoR(str, XmSTRING_DEFAULT_CHARSET);
  438.   XtSetArg(wargs[0], XmNlabelString, xmstr);
  439.   XtSetValues(w, wargs, 1);
  440.   va_end(args);
  441. }
  442.